Formal Methods in Agent-Oriented Design and Analysis

Intelligent agents are becoming one of the most important topics in distributed and autonomous decentralized systems, and there are increasing attempts to use agent technologies to develop large-scale commercial and industrial software systems. The complexity of such systems suggests a pressing need for system modeling techniques to support reliable, maintainable and extensible design. The mission of this proposed chapter is to describe an approach for using a formal model in the design of agents. The approach is based on G-nets, which are a type of Petri net defined to support system modeling in terms of a set of independent and loosely-coupled modules. We customize the basic G-net model to define a so-called “agent-oriented G-net” that can serve as a generic model for agent design. To illustrate our formal modeling technique for multi-agent systems, an example of an agent family in electronic commerce is provided. Finally, we discuss our future research plans. 1. An Introduction to Formal Methods for Agent Design This section of the proposed chapter will introduce the use of formal methods for agent design and highlight related works. The following is a condensed version of this section. Intelligent agents can be considered as active objects, or objects with mental states [1]. However, intelligent agents are quite different from objects in terms of communication mechanisms and decision-making capabilities. As a result, the object-oriented methodologies are not quite suitable for agent modeling. Especially, they do not directly support asynchronous message-passing and autonomous behavior modeling. Therefore, agent-oriented methodologies are proposed to provide guidelines for agent specification and design. Examples of such work are the AAII methodologies [3] and the Gaia methodologies [11]. Both of these two agent-oriented methodologies are extensions of object-oriented methodologies [12]. Although there are many efforts aimed at developing agent-based systems, there is sparse research on formal specification and design of such systems. As agent technology begins to emerge as a viable solution for large-scale industrial and commercial applications, there is an increasing need to ensure that the systems being developed are robust, reliable and fit for purpose [2]. Previous work on formal modeling agent systems includes the DESIRE model [4], the dMARS model [5], and agent models based on Petri nets [6]. The DESIRE model provides a compositional framework for modeling agents, and the dMARS model is based on Procedure Reasoning System (PRS), which supports formal reasoning. A typical example of agent models based on Petri nets is Moldt and Wienberg’s work, in which they proposed a multi-agent system model based on colored Petri nets. The weakness of these models is that they do not explicitly model agent communications, which is one of the key issues for intelligent agent modeling. Another problem is that they do not address the issue of inheritance. Therefore, in our perspective, these models are agent-based rather than agent-oriented. Unlike the previous work, our proposed agent model supports protocol-based agent communication. Meanwhile, by introducing inheritance mechanisms, and separating the transitional object-oriented features and reasoning mechanisms in our proposed agent-oriented model, we show that reuse can be achieved in terms of functional units defined in an agent model. Furthermore, since we uniformly use net-based formalism for agent modeling, our formal agent designs could be analyzed by using existing Petri net tools. Proposal for book chapters in Intelligent Agent Software Engineering, March 2001 Page 2 2. A Net-based Approach for Agent-Oriented Design This section of the proposed chapter will discuss our Petri net based approach for agent design. The following is a condensed version of this section. 2.1 The G-net Model A widely accepted software engineering principle is that a system should be composed of a set of independent modules, where each module hides the internal details of its processing activities and modules communicate through well-defined interfaces. The G-net model provides strong support for this principle [9]. G-nets are an object-based extension of Petri nets [8], which is a graphically defined model for synchronous concurrent systems. A G-net system is composed of a number of G-nets, each of them representing a self-contained module or object. A G-net is composed of two parts: a special place called Generic Switch Place (GSP) and an Internal Structure (IS). The GSP provides the abstraction of the module, and serves as the only interface between the G-net and other modules. The IS, a modified Petri net, represents the detailed design of the module. A GSP of a G-net G contains a set of methods G.MS specifying the services or interfaces provided by the module, and a set of attributes, G.AS, which are state variables. In G.IS, the internal structure of G-net G, Petri net places represent primitives, while transitions, together with arcs, represent connections or relations among those primitives. The primitives may define local actions or method calls. Method calls are represented by special places called Instantiated Switch Places (ISP). A primitive becomes enabled if it receives a token, and an enabled primitive can be executed. The G-net model supports the Client-Server paradigm, and it is suitable for object-based design, however, it is not sufficient for agent design because the G-net model does not directly support the following features. First, intelligent agents in multi-agent systems are usually developed by different vendors independently, therefore it is essential for them to have a common communication language and to follow common protocols. Second, the underlying agent communication model is usually asynchronous, and an agent may decide whether to perform actions requested by some other agents. Third, agents are commonly designed to determine their behavior based on individual goals, their knowledge and the environment. They may autonomously and spontaneously initiate internal or external behavior at any time. 2.2 A Framework for Agent-Oriented Modeling To support agent-oriented design, we first need to extend a G-net to support class modeling [14][15]. This can be simply done by interpreting a G-net as a model of agent class; meanwhile we need to define the instantiation of a G-net with the following two steps: to generate a unique agent identifier G.Aid, and to initialize the mental state of the resulting agent object. In addition, at the class level, five special modules are introduced to make an agent autonomous and internally-motivated. They are the Goal module, the Plan module, the Knowledge-base module, the Environment module and the Planner module. The template for an agent-oriented G-net model is shown in Figure 1. The Goal, Plan and Knowledge-base module are based on the BDI agent model [3], while the Environment module is an abstract model of the environment, i.e., the model of the outside world of an agent. The Planner module represents the heart of an agent that may decide to ignore an incoming message, to start a new conversation, or to continue with the current conversation. In the Planner module, committed plans are achieved, and the Goal, Plan and Knowledge-base modules of an agent are updated after each communicative act [10] or if the environment changes. The internal structure (IS) of an agent-oriented G-net consists of three sections: incoming message, outgoing message, and private utility. The incoming/outgoing message section defines a set of message processing units (MPU), which correspond to a subset of communicative acts. Each MPU, labeled as action_i in Figure 1, is used to process incoming/outgoing messages, and may use ISP-type modeling for calls to methods defined in its private utility section. Although both objects (passive objects) and agents use message-passing to communicate with each other, messagepassing for objects is a unique form of method invocation, while agents distinguish different types of messages and model these messages frequently as speech-acts and use complex protocols to negotiate [2]. In particular, these messages must satisfy standardized communicative (speech) acts, which define the type and the content of the message (e.g., the FIPA agent communication language, or KQML) [10]. Note that in Figure 1, each named MPU action_i refers to a communicative act, thus our agent-oriented model supports an agent communication interface. In addition, agents analyze these messages and can decide whether to execute the requested action. As we stated before, agent communications are typically based on asynchronous message passing. Since asynchronous message passing is more Proposal for book chapters in Intelligent Agent Software Engineering, March 2001 Page 3 fundamental than synchronous message passing, it is useful for us to introduce a new mechanism, called Messagepassing Switch Place (MSP), to directly support asynchronous message passing.